package com.amap.maps.jsmap.demo;


import android.Manifest;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.app.ListActivity;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ListAdapter;
import android.widget.ListView;

import com.amap.api.maps.MapsInitializer;
import com.amap.maps.jsmap.demo.webview.WebviewMapActivity;
import com.amap.maps.jsmap.demo.webview.WebviewTestActivity;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * AMapV2地图demo总汇
 */
public final class MainActivity extends ListActivity {
    // 内部类 DemoDetails，用于表示演示示例的详细信息
    private static class DemoDetails {
        // titleId - 用于存储标题的资源ID
        private int titleId;
        // descriptionId - 用于存储描述的资源ID
        private int descriptionId;
        // title - 用于存储标题的字符串
        private String title;
        // description - 用于存储描述的字符串
        private String description;
        // activityClass - 用于存储与该示例相关联的活动的类
        private final Class<? extends android.app.Activity> activityClass;

        // 构造函数，使用资源ID作为标题和描述
        public DemoDetails(int titleId, int descriptionId,
                           Class<? extends android.app.Activity> activityClass) {
            super(); // 调用父类的构造函数
            this.titleId = titleId; // 初始化标题资源ID
            this.descriptionId = descriptionId; // 初始化描述资源ID
            this.activityClass = activityClass; // 初始化活动类
        }

        // 构造函数，使用字符串作为标题和描述
        public DemoDetails(String title, String description,
                           Class<? extends android.app.Activity> activityClass) {
            super(); // 调用父类的构造函数
            this.title = title; // 初始化标题字符串
            this.description = description; // 初始化描述字符串
            this.activityClass = activityClass; // 初始化活动类
        }

        // 构造函数，使用资源ID作为标题和字符串作为描述
        public DemoDetails(int titleId, String description,
                           Class<? extends android.app.Activity> activityClass) {
            super(); // 调用父类的构造函数
            this.titleId = titleId; // 初始化标题资源ID
            this.description = description; // 初始化描述字符串
            this.activityClass = activityClass; // 初始化活动类
        }

        // 构造函数，使用字符串作为标题和资源ID作为描述
        public DemoDetails(String title, int descriptionId,
                           Class<? extends android.app.Activity> activityClass) {
            super(); // 调用父类的构造函数
            this.title = title; // 初始化标题字符串
            this.descriptionId = descriptionId; // 初始化描述资源ID
            this.activityClass = activityClass; // 初始化活动类
        }
    }

    // 内部类 CustomArrayAdapter 继承自 ArrayAdapter，用于处理 DemoDetails 对象的数组
    private static class CustomArrayAdapter extends ArrayAdapter<DemoDetails> {
        // 构造函数，初始化 ArrayAdapter
        public CustomArrayAdapter(Context context, DemoDetails[] demos) {
            super(context, R.layout.feature, R.id.title, demos); // 调用父类的构造方法，设置布局和数据
        }

        // 重写 getView 方法，用于为每个列表项创建视图
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            FeatureView featureView;
            // 检查传入的 convertView 实例是否是 FeatureView 类型
            if (convertView instanceof FeatureView) {
                featureView = (FeatureView) convertView; // 如果是，直接使用该视图
            } else {
                featureView = new FeatureView(getContext()); // 否则，创建一个新的 FeatureView 实例
            }

            // 获取当前位置的 DemoDetails 对象
            DemoDetails demo = getItem(position);

            // 如果 titleId 不为 0，设置 FeatureView 的标题资源ID
            if (demo.titleId != 0) {
                featureView.setTitleId(demo.titleId, demo.activityClass != null);
            }

            // 如果 title 不为 null，设置 FeatureView 的标题文本
            if (demo.title != null) {
                featureView.setTitle(demo.title, demo.activityClass != null);
            }

            // 如果 descriptionId 不为 0，设置 FeatureView 的描述资源ID
            if (demo.descriptionId != 0) {
                featureView.setDescriptionId(demo.descriptionId);
            }

            // 如果 description 不为 null，设置 FeatureView 的描述文本
            if (demo.description != null) {
                featureView.setDescription(demo.description);
            }

            // 返回配置好的 FeatureView 实例
            return featureView;
        }
    }

    // 定义一个静态的 DemoDetails 数组，存储各种地图功能的演示
    private static final DemoDetails[] demos = {
            // 创建地图（此行被注释掉了，不会被包含在数组中）
            // new DemoDetails(R.string.map_create, R.string.blank, null),

            // 显示地图 - 第一个 WebView 示例，用于检查浏览器内核
            new DemoDetails("第一个WebView-检查浏览器内核", R.string.basic_description,
                    WebviewTestActivity.class),

            // 基础地图功能的演示
            new DemoDetails(R.string.basic_map, R.string.basic_description,
                    BasicMapActivity.class),

            // 使用外部 WebView 内核的演示
            new DemoDetails("外部WebView内核", R.string.basic_description,
                    WebviewMapActivity.class),

            // 添加缩放控件、定位按钮、指南针、比例尺等的演示
            new DemoDetails(R.string.uisettings_demo,
                    R.string.uisettings_description, UiSettingsActivity.class),

            // 绘制点的演示
            new DemoDetails(R.string.marker_demo, R.string.marker_description,
                    MarkerActivity.class),

            // 定位小蓝点的功能演示
            new DemoDetails("定位小蓝点", R.string.locationmodesource_description, LocationModeSourceActivity_OutLocation.class),

            // 绘制实线和虚线的演示
            new DemoDetails(R.string.polyline_demo,
                    R.string.polyline_description, PolylineActivity.class),

            // 平滑移动的功能演示
            new DemoDetails(R.string.smooth_move_demo, R.string.smooth_move_description, SmoothMoveActivity.class),
    };

    // 当活动创建时调用
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // 调用父类的onCreate方法来完成创建过程
        super.onCreate(savedInstanceState);
        // 设置活动的布局文件
        setContentView(R.layout.activity_main);
        // 设置活动的标题，包括高德地图的版本号
        setTitle("3D地图Demo" + MapsInitializer.getVersion());

        // 创建并设置自定义的 ArrayAdapter，用于在列表视图中显示地图功能的演示
        ListAdapter adapter = new CustomArrayAdapter(
                this.getApplicationContext(), demos);
        setListAdapter(adapter); // 设置ListAdapter以用于管理ListView中的数据
    }

    // 当用户按下返回键时调用
    @Override
    public void onBackPressed() {
        // 调用父类的onBackPressed方法来处理返回键事件
        super.onBackPressed();
        // 退出应用程序
        System.exit(0);
    }

    Class testClass = null;

    // 当列表项被点击时调用
    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        // 从列表适配器中获取被点击的 DemoDetails 对象
        DemoDetails demo = (DemoDetails) getListAdapter().getItem(position);

        // 检查 DemoDetails 对象是否有关联的活动类
        if (demo.activityClass != null) {
            Log.i("MY", "demo!=null"); // 记录日志，表示找到了有效的活动类

            // 创建一个意图来启动关联的活动，并使用 startActivityForResult 启动它
            // 这样可以从启动的活动中获取结果
            startActivityForResult(new Intent(this.getApplicationContext(),
                    demo.activityClass), 1000);
        }
    }

    // 当从一个活动返回结果时调用
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data); // 调用父类方法处理结果

        // 检查返回的结果码是否是 1000，并且 testClass 不为空
        if (resultCode == 1000 && testClass != null) {
            // 再次启动 testClass 指定的活动，并期待获取结果
            startActivityForResult(new Intent(this.getApplicationContext(),
                    testClass), 1000);
        }
    }

    /*************************************** 权限检查******************************************************/
    //是否需要检测后台定位权限，设置为true时，如果用户没有给予后台定位权限会弹窗提示
    private boolean needCheckBackLocation = false;
    //如果设置了target > 28，需要增加这个权限，否则不会弹出"始终允许"这个选择框
    private static String BACK_LOCATION_PERMISSION = "android.permission.ACCESS_BACKGROUND_LOCATION";
    /**
     * 需要进行检测的权限数组
     */
    // 需要请求的权限数组
    protected String[] needPermissions = {
            Manifest.permission.ACCESS_COARSE_LOCATION, // 粗略定位权限
            Manifest.permission.ACCESS_FINE_LOCATION, // 精确定位权限
            Manifest.permission.WRITE_EXTERNAL_STORAGE, // 写入外部存储权限
            BACK_LOCATION_PERMISSION // 后台定位权限，这是自定义的一个静态字段
    };

    // 权限请求的请求码，用于 onActivityResult 回调中识别请求来源
    private static final int PERMISSON_REQUESTCODE = 0;

    /**
     * 判断是否需要检测，防止不停的弹框
     */
    private boolean isNeedCheck = true;

    // 当活动恢复时调用
    @Override
    protected void onResume() {
        try {
            super.onResume(); // 调用父类的 onResume 方法来完成标准的恢复流程

            // 检查当前运行的 Android 版本是否高于或等于 23（即 Android 6.0 Marshmallow）
            // 从 Android 6.0 开始，需要在运行时请求权限
            if (Build.VERSION.SDK_INT >= 23) {
                // 检查是否需要检查权限
                if (isNeedCheck) {
                    // 调用自定义的 checkPermissions 方法来检查并请求所需的权限
                    checkPermissions(needPermissions);
                }
            }
        } catch (Throwable e) {
            e.printStackTrace(); // 捕获并打印可能出现的异常
        }
    }

    /**
     * @param
     * @since 2.5.0
     */
    // 使用 @TargetApi(23) 注解标记此方法，表示它是针对 API 级别 23 及以上版本设计的
    @TargetApi(23)
    private void checkPermissions(String... permissions) {
        try {
            // 检查当前运行的 Android 版本以及应用的目标 SDK 版本是否都是 23 或以上
            // 这是因为自 Android 6.0（API 级别 23）开始，引入了运行时权限请求
            if (Build.VERSION.SDK_INT >= 23 && getApplicationInfo().targetSdkVersion >= 23) {
                // 调用 findDeniedPermissions 方法来获取那些还未被授权的权限
                List<String> needRequestPermissionList = findDeniedPermissions(permissions);

                // 检查是否有未授权的权限
                if (null != needRequestPermissionList && needRequestPermissionList.size() > 0) {
                    try {
                        // 将需要请求的权限列表转换为数组
                        String[] array = needRequestPermissionList.toArray(new String[needRequestPermissionList.size()]);

                        // 反射调用 requestPermissions 方法请求权限
                        // 这是一种编程技巧，通常不推荐在常规开发中使用反射进行权限请求
                        Method method = getClass().getMethod("requestPermissions", new Class[]{String[].class, int.class});
                        method.invoke(this, array, PERMISSON_REQUESTCODE);
                    } catch (Throwable e) {
                        // 异常处理
                        // 在这里可能捕获到反射调用过程中的异常
                    }
                }
            }
        } catch (Throwable e) {
            e.printStackTrace(); // 捕获并打印可能出现的异常
        }
    }


    /**
     * 获取权限集中需要申请权限的列表
     *
     * @param permissions
     * @return
     * @since 2.5.0
     */
    @TargetApi(23)
    private List<String> findDeniedPermissions(String[] permissions) {
        try {
            List<String> needRequestPermissonList = new ArrayList<String>();
            if (Build.VERSION.SDK_INT >= 23 && getApplicationInfo().targetSdkVersion >= 23) {
                for (String perm : permissions) {
                    if (checkMySelfPermission(perm) != PackageManager.PERMISSION_GRANTED
                            || shouldShowMyRequestPermissionRationale(perm)) {
                        if (!needCheckBackLocation
                                && BACK_LOCATION_PERMISSION.equals(perm)) {
                            continue;
                        }
                        needRequestPermissonList.add(perm);
                    }
                }
            }
            return needRequestPermissonList;
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }

    private int checkMySelfPermission(String perm) {
        try {
            Method method = getClass().getMethod("checkSelfPermission", new Class[]{String.class});
            Integer permissionInt = (Integer) method.invoke(this, perm);
            return permissionInt;
        } catch (Throwable e) {
        }
        return -1;
    }

    private boolean shouldShowMyRequestPermissionRationale(String perm) {
        try {
            Method method = getClass().getMethod("shouldShowRequestPermissionRationale", new Class[]{String.class});
            Boolean permissionInt = (Boolean) method.invoke(this, perm);
            return permissionInt;
        } catch (Throwable e) {
        }
        return false;
    }

    /**
     * 检测是否说有的权限都已经授权
     *
     * @param grantResults
     * @return
     * @since 2.5.0
     */
    // 使用 @TargetApi(23) 注解标记此方法，表示它是针对 API 级别 23 及以上版本设计的
    @TargetApi(23)
    private List<String> findDeniedPermissions(String[] permissions) {
        try {
            // 初始化一个列表来存储需要请求的权限
            List<String> needRequestPermissionList = new ArrayList<String>();

            // 检查当前运行的 Android 版本以及应用的目标 SDK 版本是否都是 23 或以上
            if (Build.VERSION.SDK_INT >= 23 && getApplicationInfo().targetSdkVersion >= 23) {
                // 遍历传入的权限数组
                for (String perm : permissions) {
                    // 检查是否拥有该权限或是否应该显示权限请求的理由
                    if (checkMySelfPermission(perm) != PackageManager.PERMISSION_GRANTED
                            || shouldShowMyRequestPermissionRationale(perm)) {
                        // 如果不需要检查后台位置权限并且当前权限是后台位置权限，则跳过
                        if (!needCheckBackLocation && BACK_LOCATION_PERMISSION.equals(perm)) {
                            continue;
                        }
                        // 将权限添加到请求列表中
                        needRequestPermissionList.add(perm);
                    }
                }
            }
            return needRequestPermissionList;
        } catch (Throwable e) {
            e.printStackTrace(); // 打印异常
        }
        return null; // 发生异常时返回 null
    }

    // 自定义的检查权限方法，使用反射调用系统的 checkSelfPermission 方法
    private int checkMySelfPermission(String perm) {
        try {
            // 反射获取 checkSelfPermission 方法
            Method method = getClass().getMethod("checkSelfPermission", new Class[]{String.class});
            // 调用方法并返回权限检查结果
            Integer permissionInt = (Integer) method.invoke(this, perm);
            return permissionInt;
        } catch (Throwable e) {
            // 异常处理，这里忽略了异常的详细信息
        }
        return -1; // 发生异常时返回 -1
    }

    // 自定义的方法，使用反射调用系统的 shouldShowRequestPermissionRationale 方法
    private boolean shouldShowMyRequestPermissionRationale(String perm) {
        try {
            // 反射获取 shouldShowRequestPermissionRationale 方法
            Method method = getClass().getMethod("shouldShowRequestPermissionRationale", new Class[]{String.class});
            // 调用方法并返回是否应显示权限请求理由
            Boolean permissionInt = (Boolean) method.invoke(this, perm);
            return permissionInt;
        } catch (Throwable e) {
            // 异常处理，这里忽略了异常的详细信息
        }
        return false; // 发生异常时返回 false
    }


    /**
     * 显示提示信息
     *
     * @since 2.5.0
     */
    private void showMissingPermissionDialog() {
        try {
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle("提示");
            builder.setMessage("当前应用缺少必要权限。\\n\\n请点击\\\"设置\\\"-\\\"权限\\\"-打开所需权限");

            // 拒绝, 退出应用
            builder.setNegativeButton("取消",
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            try {
                                finish();
                            } catch (Throwable e) {
                                e.printStackTrace();
                            }
                        }
                    });

            builder.setPositiveButton("设置",
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            try {
                                startAppSettings();
                            } catch (Throwable e) {
                                e.printStackTrace();
                            }
                        }
                    });

            builder.setCancelable(false);

            builder.show();
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    /**
     * 启动应用的设置
     *
     * @since 2.5.0
     */
    private void startAppSettings() {
        try {
            Intent intent = new Intent(
                    Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
            intent.setData(Uri.parse("package:" + getPackageName()));
            startActivity(intent);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}
